home *** CD-ROM | disk | FTP | other *** search
/ PD Collection CD 1 / PD Collection CD 1.iso / textual / tex / files / !tex / TeXsource / web2ctex / ctex / c / tex2 < prev    next >
Encoding:
Text File  |  1988-05-19  |  43.8 KB  |  2,118 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. preparemag () {
  5.     preparemag_regmem 
  6.   if ( ( magset > 0 ) && ( eqtb [ 5284 ] .cint != magset ) ) 
  7.   {
  8.     {
  9.       if ( interaction == 3 ) 
  10.       wakeupterminal () ; 
  11.       printnl ( 133 ) ; 
  12.       print ( 405 ) ; 
  13.     } 
  14.     printint ( eqtb [ 5284 ] .cint ) ; 
  15.     print ( 406 ) ; 
  16.     printnl ( 407 ) ; 
  17.     {
  18.       helpptr = 2 ; 
  19.       helpline [ 1 ] = 408 ; 
  20.       helpline [ 0 ] = 409 ; 
  21.     } 
  22.     interror ( magset ) ; 
  23.     geqworddefine ( 5284 , magset ) ; 
  24.   } 
  25.   if ( ( eqtb [ 5284 ] .cint <= 0 ) || ( eqtb [ 5284 ] .cint > 32768L ) ) 
  26.   {
  27.     {
  28.       if ( interaction == 3 ) 
  29.       wakeupterminal () ; 
  30.       printnl ( 133 ) ; 
  31.       print ( 410 ) ; 
  32.     } 
  33.     {
  34.       helpptr = 1 ; 
  35.       helpline [ 0 ] = 411 ; 
  36.     } 
  37.     interror ( eqtb [ 5284 ] .cint ) ; 
  38.     geqworddefine ( 5284 , 1000 ) ; 
  39.   } 
  40.   magset = eqtb [ 5284 ] .cint ; 
  41. } 
  42. ztokenshow ( p ) 
  43. halfword p ; 
  44. {tokenshow_regmem 
  45.   if ( p != 0 ) 
  46.   showtokenlist ( mem [ p ] .hh .v.RH , 0 , 1000 ) ; 
  47. } 
  48. printmeaning () {
  49.     printmeaning_regmem 
  50.   printcmdchr ( curcmd , curchr ) ; 
  51.   if ( curcmd >= 110 ) 
  52.   {
  53.     printchar ( 58 ) ; 
  54.     println () ; 
  55.     tokenshow ( curchr ) ; 
  56.   } 
  57.   else if ( curcmd == 109 ) 
  58.   {
  59.     printchar ( 58 ) ; 
  60.     println () ; 
  61.     tokenshow ( curmark [ curchr ] ) ; 
  62.   } 
  63. } 
  64. showcurcmdchr () {
  65.     showcurcmdchr_regmem 
  66.   begindiagnostic () ; 
  67.   printnl ( 123 ) ; 
  68.   if ( curlist .modefield != shownmode ) 
  69.   {
  70.     printmode ( curlist .modefield ) ; 
  71.     print ( 426 ) ; 
  72.     shownmode = curlist .modefield ; 
  73.   } 
  74.   printcmdchr ( curcmd , curchr ) ; 
  75.   printchar ( 125 ) ; 
  76.   enddiagnostic ( false ) ; 
  77. } 
  78. showcontext () {
  79.     /* 30 */ showcontext_regmem 
  80.   schar oldsetting  ; 
  81.   integer i  ; 
  82.   integer j  ; 
  83.   integer l  ; 
  84.   integer m  ; 
  85.   integer n  ; 
  86.   integer p  ; 
  87.   integer q  ; 
  88.   baseptr = inputptr ; 
  89.   inputstack [ baseptr ] = curinput ; 
  90.   while ( true ) {
  91.       
  92.     curinput = inputstack [ baseptr ] ; 
  93.     if ( ( baseptr == inputptr ) || ( curinput .statefield != 0 ) || ( 
  94.     curinput .indexfield != 3 ) || ( curinput .locfield != 0 ) ) 
  95.     {
  96.       tally = 0 ; 
  97.       oldsetting = selector ; 
  98.       if ( curinput .statefield != 0 ) 
  99.       {
  100.     if ( curinput .namefield <= 17 ) 
  101.     if ( ( curinput .namefield == 0 ) ) 
  102.     if ( baseptr == 0 ) 
  103.     printnl ( 432 ) ; 
  104.     else printnl ( 433 ) ; 
  105.     else {
  106.         
  107.       printnl ( 434 ) ; 
  108.       if ( curinput .namefield == 17 ) 
  109.       printchar ( 42 ) ; 
  110.       else printint ( curinput .namefield - 1 ) ; 
  111.       printchar ( 62 ) ; 
  112.     } 
  113.     else {
  114.         
  115.       printnl ( 435 ) ; 
  116.       printint ( line ) ; 
  117.     } 
  118.     printchar ( 32 ) ; 
  119.     {
  120.       l = tally ; 
  121.       tally = 0 ; 
  122.       selector = 20 ; 
  123.       trickcount = 1000000L ; 
  124.     } 
  125.     if ( buffer [ curinput .limitfield ] == eqtb [ 5315 ] .cint ) 
  126.     j = curinput .limitfield ; 
  127.     else j = curinput .limitfield + 1 ; 
  128.     if ( j > 0 ) 
  129.     {register integer for_end; i = curinput .startfield ; for_end = j - 1 
  130.     ; if ( i <= for_end) do 
  131.       {
  132.         if ( i == curinput .locfield ) 
  133.         {
  134.           firstcount = tally ; 
  135.           trickcount = tally + 1 + errorline - halferrorline ; 
  136.           if ( trickcount < errorline ) 
  137.           trickcount = errorline ; 
  138.         } 
  139.         print ( buffer [ i ] ) ; 
  140.       } 
  141.     while ( i++ < for_end ) ; } 
  142.       } 
  143.       else {
  144.       
  145.     switch ( curinput .indexfield ) 
  146.     {case 0 : 
  147.       printnl ( 436 ) ; 
  148.       break ; 
  149.     case 1 : 
  150.     case 2 : 
  151.       printnl ( 437 ) ; 
  152.       break ; 
  153.     case 3 : 
  154.       if ( curinput .locfield == 0 ) 
  155.       printnl ( 438 ) ; 
  156.       else printnl ( 439 ) ; 
  157.       break ; 
  158.     case 4 : 
  159.       printnl ( 440 ) ; 
  160.       break ; 
  161.     case 5 : 
  162.       {
  163.         println () ; 
  164.         printcs ( curinput .namefield ) ; 
  165.       } 
  166.       break ; 
  167.     case 6 : 
  168.       printnl ( 441 ) ; 
  169.       break ; 
  170.     case 7 : 
  171.       printnl ( 442 ) ; 
  172.       break ; 
  173.     case 8 : 
  174.       printnl ( 443 ) ; 
  175.       break ; 
  176.     case 9 : 
  177.       printnl ( 444 ) ; 
  178.       break ; 
  179.     case 10 : 
  180.       printnl ( 445 ) ; 
  181.       break ; 
  182.     case 11 : 
  183.       printnl ( 446 ) ; 
  184.       break ; 
  185.     case 12 : 
  186.       printnl ( 447 ) ; 
  187.       break ; 
  188.     case 13 : 
  189.       printnl ( 448 ) ; 
  190.       break ; 
  191.     case 14 : 
  192.       printnl ( 449 ) ; 
  193.       break ; 
  194.     case 15 : 
  195.       printnl ( 450 ) ; 
  196.       break ; 
  197.       default: 
  198.       printnl ( 63 ) ; 
  199.       break ; 
  200.     } 
  201.     {
  202.       l = tally ; 
  203.       tally = 0 ; 
  204.       selector = 20 ; 
  205.       trickcount = 1000000L ; 
  206.     } 
  207.     if ( curinput .indexfield < 5 ) 
  208.     showtokenlist ( curinput .startfield , curinput .locfield , 100000L ) 
  209.     ; 
  210.     else showtokenlist ( mem [ curinput .startfield ] .hh .v.RH , curinput 
  211.     .locfield , 100000L ) ; 
  212.       } 
  213.       selector = oldsetting ; 
  214.       if ( trickcount == 1000000L ) 
  215.       {
  216.     firstcount = tally ; 
  217.     trickcount = tally + 1 + errorline - halferrorline ; 
  218.     if ( trickcount < errorline ) 
  219.     trickcount = errorline ; 
  220.       } 
  221.       if ( tally < trickcount ) 
  222.       m = tally - firstcount ; 
  223.       else m = trickcount - firstcount ; 
  224.       if ( l + firstcount <= halferrorline ) 
  225.       {
  226.     p = 0 ; 
  227.     n = l + firstcount ; 
  228.       } 
  229.       else {
  230.       
  231.     print ( 146 ) ; 
  232.     p = l + firstcount - halferrorline + 3 ; 
  233.     n = halferrorline ; 
  234.       } 
  235.       {register integer for_end; q = p ; for_end = firstcount - 1 ; if ( q <= 
  236.       for_end) do 
  237.     printchar ( trickbuf [ q % errorline ] ) ; 
  238.       while ( q++ < for_end ) ; } 
  239.       println () ; 
  240.       {register integer for_end; q = 1 ; for_end = n ; if ( q <= for_end) do 
  241.     printchar ( 32 ) ; 
  242.       while ( q++ < for_end ) ; } 
  243.       if ( m + n <= errorline ) 
  244.       p = firstcount + m ; 
  245.       else p = firstcount + ( errorline - n - 3 ) ; 
  246.       {register integer for_end; q = firstcount ; for_end = p - 1 ; if ( q <= 
  247.       for_end) do 
  248.     printchar ( trickbuf [ q % errorline ] ) ; 
  249.       while ( q++ < for_end ) ; } 
  250.       if ( m + n > errorline ) 
  251.       print ( 146 ) ; 
  252.     } 
  253.     if ( ( curinput .statefield != 0 ) ) 
  254.     if ( ( curinput .namefield > 17 ) || ( baseptr == 0 ) ) 
  255.     goto lab30 ; 
  256.     decr ( baseptr ) ; 
  257.   } 
  258.   lab30: curinput = inputstack [ inputptr ] ; 
  259. } 
  260. zbegintokenlist ( p , t ) 
  261. halfword p ; 
  262. quarterword t ; 
  263. {begintokenlist_regmem 
  264.   {
  265.     if ( inputptr > maxinstack ) 
  266.     {
  267.       maxinstack = inputptr ; 
  268.       if ( inputptr == stacksize ) 
  269.       overflow ( 451 , stacksize ) ; 
  270.     } 
  271.     inputstack [ inputptr ] = curinput ; 
  272.     incr ( inputptr ) ; 
  273.   } 
  274.   curinput .statefield = 0 ; 
  275.   curinput .startfield = p ; 
  276.   curinput .indexfield = t ; 
  277.   if ( t >= 5 ) 
  278.   {
  279.     incr ( mem [ p ] .hh .v.LH ) ; 
  280.     if ( t == 5 ) 
  281.     curinput .limitfield = paramptr ; 
  282.     else {
  283.     
  284.       curinput .locfield = mem [ p ] .hh .v.RH ; 
  285.       if ( eqtb [ 5297 ] .cint > 1 ) 
  286.       {
  287.     begindiagnostic () ; 
  288.     printnl ( 206 ) ; 
  289.     switch ( t ) 
  290.     {case 14 : 
  291.       printesc ( 219 ) ; 
  292.       break ; 
  293.     case 15 : 
  294.       printesc ( 452 ) ; 
  295.       break ; 
  296.       default: 
  297.       printcmdchr ( 71 , t + 4051 ) ; 
  298.       break ; 
  299.     } 
  300.     print ( 414 ) ; 
  301.     tokenshow ( p ) ; 
  302.     enddiagnostic ( false ) ; 
  303.       } 
  304.     } 
  305.   } 
  306.   else curinput .locfield = p ; 
  307. } 
  308. endtokenlist () {
  309.     endtokenlist_regmem 
  310.   if ( curinput .indexfield >= 3 ) 
  311.   {
  312.     if ( curinput .indexfield <= 4 ) 
  313.     flushlist ( curinput .startfield ) ; 
  314.     else {
  315.     
  316.       deletetokenref ( curinput .startfield ) ; 
  317.       if ( curinput .indexfield == 5 ) 
  318.       while ( paramptr > curinput .limitfield ) {
  319.       
  320.     decr ( paramptr ) ; 
  321.     flushlist ( paramstack [ paramptr ] ) ; 
  322.       } 
  323.     } 
  324.   } 
  325.   else if ( curinput .indexfield == 1 ) 
  326.   alignstate = 0 ; 
  327.   {
  328.     decr ( inputptr ) ; 
  329.     curinput = inputstack [ inputptr ] ; 
  330.   } 
  331.   {
  332.     if ( interrupt != 0 ) 
  333.     pauseforinstructions () ; 
  334.   } 
  335. } 
  336. backinput () {
  337.     backinput_regmem 
  338.   halfword p  ; 
  339.   while ( ( curinput .statefield == 0 ) && ( curinput .locfield == 0 ) ) 
  340.   endtokenlist () ; 
  341.   p = getavail () ; 
  342.   mem [ p ] .hh .v.LH = curtok ; 
  343.   if ( curtok < 768 ) 
  344.   if ( curtok < 512 ) 
  345.   decr ( alignstate ) ; 
  346.   else incr ( alignstate ) ; 
  347.   {
  348.     if ( inputptr > maxinstack ) 
  349.     {
  350.       maxinstack = inputptr ; 
  351.       if ( inputptr == stacksize ) 
  352.       overflow ( 451 , stacksize ) ; 
  353.     } 
  354.     inputstack [ inputptr ] = curinput ; 
  355.     incr ( inputptr ) ; 
  356.   } 
  357.   curinput .statefield = 0 ; 
  358.   curinput .startfield = p ; 
  359.   curinput .indexfield = 3 ; 
  360.   curinput .locfield = p ; 
  361. } 
  362. backerror () {
  363.     backerror_regmem 
  364.   OKtointerrupt = false ; 
  365.   backinput () ; 
  366.   OKtointerrupt = true ; 
  367.   error () ; 
  368. } 
  369. inserror () {
  370.     inserror_regmem 
  371.   OKtointerrupt = false ; 
  372.   backinput () ; 
  373.   curinput .indexfield = 4 ; 
  374.   OKtointerrupt = true ; 
  375.   error () ; 
  376. } 
  377. beginfilereading () {
  378.     beginfilereading_regmem 
  379.   if ( inopen == maxinopen ) 
  380.   overflow ( 453 , maxinopen ) ; 
  381.   if ( first == bufsize ) 
  382.   overflow ( 454 , bufsize ) ; 
  383.   incr ( inopen ) ; 
  384.   {
  385.     if ( inputptr > maxinstack ) 
  386.     {
  387.       maxinstack = inputptr ; 
  388.       if ( inputptr == stacksize ) 
  389.       overflow ( 451 , stacksize ) ; 
  390.     } 
  391.     inputstack [ inputptr ] = curinput ; 
  392.     incr ( inputptr ) ; 
  393.   } 
  394.   curinput .indexfield = inopen ; 
  395.   linestack [ curinput .indexfield ] = line ; 
  396.   curinput .startfield = first ; 
  397.   curinput .statefield = 1 ; 
  398.   curinput .namefield = 0 ; 
  399. } 
  400. endfilereading () {
  401.     endfilereading_regmem 
  402.   first = curinput .startfield ; 
  403.   line = linestack [ curinput .indexfield ] ; 
  404.   if ( curinput .namefield > 17 ) 
  405.   aclose ( inputfile [ curinput .indexfield ] ) ; 
  406.   {
  407.     decr ( inputptr ) ; 
  408.     curinput = inputstack [ inputptr ] ; 
  409.   } 
  410.   decr ( inopen ) ; 
  411. } 
  412. clearforerrorprompt () {
  413.     clearforerrorprompt_regmem 
  414.   while ( ( curinput .statefield != 0 ) && ( curinput .namefield == 0 ) && ( 
  415.   inputptr > 0 ) && ( curinput .locfield > curinput .limitfield ) ) 
  416.   endfilereading () ; 
  417.   println () ; 
  418.   clearterminal () ; 
  419. } 
  420. checkoutervalidity () {
  421.     checkoutervalidity_regmem 
  422.   halfword p  ; 
  423.   halfword q  ; 
  424.   if ( scannerstatus != 0 ) 
  425.   {
  426.     deletionsallowed = false ; 
  427.     if ( curcs != 0 ) 
  428.     {
  429.       if ( ( curinput .statefield == 0 ) || ( curinput .namefield < 1 ) || ( 
  430.       curinput .namefield > 17 ) ) 
  431.       {
  432.     p = getavail () ; 
  433.     mem [ p ] .hh .v.LH = 4096 + curcs ; 
  434.     begintokenlist ( p , 3 ) ; 
  435.       } 
  436.       curcmd = 10 ; 
  437.       curchr = 32 ; 
  438.     } 
  439.     if ( scannerstatus > 1 ) 
  440.     {
  441.       runaway () ; 
  442.       if ( curcs == 0 ) 
  443.       {
  444.     if ( interaction == 3 ) 
  445.     wakeupterminal () ; 
  446.     printnl ( 133 ) ; 
  447.     print ( 462 ) ; 
  448.       } 
  449.       else {
  450.       
  451.     curcs = 0 ; 
  452.     {
  453.       if ( interaction == 3 ) 
  454.       wakeupterminal () ; 
  455.       printnl ( 133 ) ; 
  456.       print ( 463 ) ; 
  457.     } 
  458.       } 
  459.       print ( 464 ) ; 
  460.       p = getavail () ; 
  461.       switch ( scannerstatus ) 
  462.       {case 2 : 
  463.     {
  464.       print ( 428 ) ; 
  465.       mem [ p ] .hh .v.LH = 637 ; 
  466.     } 
  467.     break ; 
  468.       case 3 : 
  469.     {
  470.       print ( 470 ) ; 
  471.       mem [ p ] .hh .v.LH = partoken ; 
  472.       longstate = 112 ; 
  473.     } 
  474.     break ; 
  475.       case 4 : 
  476.     {
  477.       print ( 430 ) ; 
  478.       mem [ p ] .hh .v.LH = 637 ; 
  479.       q = p ; 
  480.       p = getavail () ; 
  481.       mem [ p ] .hh .v.RH = q ; 
  482.       mem [ p ] .hh .v.LH = 7355 ; 
  483.       alignstate = -1000000L ; 
  484.     } 
  485.     break ; 
  486.       case 5 : 
  487.     {
  488.       print ( 431 ) ; 
  489.       mem [ p ] .hh .v.LH = 637 ; 
  490.     } 
  491.     break ; 
  492.       } 
  493.       begintokenlist ( p , 4 ) ; 
  494.       print ( 465 ) ; 
  495.       sprintcs ( warningindex ) ; 
  496.       {
  497.     helpptr = 4 ; 
  498.     helpline [ 3 ] = 466 ; 
  499.     helpline [ 2 ] = 467 ; 
  500.     helpline [ 1 ] = 468 ; 
  501.     helpline [ 0 ] = 469 ; 
  502.       } 
  503.       error () ; 
  504.     } 
  505.     else {
  506.     
  507.       {
  508.     if ( interaction == 3 ) 
  509.     wakeupterminal () ; 
  510.     printnl ( 133 ) ; 
  511.     print ( 456 ) ; 
  512.       } 
  513.       printcmdchr ( 104 , curif ) ; 
  514.       print ( 457 ) ; 
  515.       printint ( skipline ) ; 
  516.       {
  517.     helpptr = 3 ; 
  518.     helpline [ 2 ] = 458 ; 
  519.     helpline [ 1 ] = 459 ; 
  520.     helpline [ 0 ] = 460 ; 
  521.       } 
  522.       if ( curcs != 0 ) 
  523.       curcs = 0 ; 
  524.       else helpline [ 2 ] = 461 ; 
  525.       curtok = 7358 ; 
  526.       inserror () ; 
  527.     } 
  528.     deletionsallowed = true ; 
  529.   } 
  530. } 
  531. getnext () {
  532.     /* 20 25 21 26 40 10 */ getnext_regmem 
  533.   integer k  ; 
  534.   halfword t  ; 
  535.   schar cat  ; 
  536.   lab20: curcs = 0 ; 
  537.   if ( curinput .statefield != 0 ) 
  538.   {
  539.     lab25: if ( curinput .locfield <= curinput .limitfield ) 
  540.     {
  541.       curchr = buffer [ curinput .locfield ] ; 
  542.       incr ( curinput .locfield ) ; 
  543.       lab21: curcmd = eqtb [ 4627 + curchr ] .hh .v.RH ; 
  544.       switch ( curinput .statefield + curcmd ) 
  545.       {case 10 : 
  546.       case 26 : 
  547.       case 42 : 
  548.       case 27 : 
  549.       case 43 : 
  550.     goto lab25 ; 
  551.     break ; 
  552.       case 1 : 
  553.       case 17 : 
  554.       case 33 : 
  555.     {
  556.       if ( curinput .locfield > curinput .limitfield ) 
  557.       curcs = 257 ; 
  558.       else {
  559.           
  560.         lab26: k = curinput .locfield ; 
  561.         curchr = buffer [ k ] ; 
  562.         cat = eqtb [ 4627 + curchr ] .hh .v.RH ; 
  563.         incr ( k ) ; 
  564.         if ( cat == 11 ) 
  565.         curinput .statefield = 17 ; 
  566.         else if ( cat == 10 ) 
  567.         curinput .statefield = 17 ; 
  568.         else curinput .statefield = 1 ; 
  569.         if ( ( cat == 11 ) && ( k <= curinput .limitfield ) ) 
  570.         {
  571.           do {
  572.           curchr = buffer [ k ] ; 
  573.         cat = eqtb [ 4627 + curchr ] .hh .v.RH ; 
  574.         incr ( k ) ; 
  575.           } while ( ! ( ( cat != 11 ) || ( k > curinput .limitfield ) ) ) 
  576.           ; 
  577.           {
  578.         if ( buffer [ k ] == curchr ) 
  579.         if ( cat == 7 ) 
  580.         if ( k < curinput .limitfield ) 
  581.         {
  582.           curchr = buffer [ k + 1 ] ; 
  583.           if ( curchr < 64 ) 
  584.           buffer [ k - 1 ] = curchr + 64 ; 
  585.           else buffer [ k - 1 ] = curchr - 64 ; 
  586.           curinput .limitfield = curinput .limitfield - 2 ; 
  587.           first = first - 2 ; 
  588.           while ( k <= curinput .limitfield ) {
  589.               
  590.             buffer [ k ] = buffer [ k + 2 ] ; 
  591.             incr ( k ) ; 
  592.           } 
  593.           goto lab26 ; 
  594.         } 
  595.           } 
  596.           if ( cat != 11 ) 
  597.           decr ( k ) ; 
  598.           if ( k > curinput .locfield + 1 ) 
  599.           {
  600.         curcs = idlookup ( curinput .locfield , k - curinput .locfield 
  601.         ) ; 
  602.         curinput .locfield = k ; 
  603.         goto lab40 ; 
  604.           } 
  605.         } 
  606.         else {
  607.         
  608.           if ( buffer [ k ] == curchr ) 
  609.           if ( cat == 7 ) 
  610.           if ( k < curinput .limitfield ) 
  611.           {
  612.         curchr = buffer [ k + 1 ] ; 
  613.         if ( curchr < 64 ) 
  614.         buffer [ k - 1 ] = curchr + 64 ; 
  615.         else buffer [ k - 1 ] = curchr - 64 ; 
  616.         curinput .limitfield = curinput .limitfield - 2 ; 
  617.         first = first - 2 ; 
  618.         while ( k <= curinput .limitfield ) {
  619.             
  620.           buffer [ k ] = buffer [ k + 2 ] ; 
  621.           incr ( k ) ; 
  622.         } 
  623.         goto lab26 ; 
  624.           } 
  625.         } 
  626.         curcs = 129 + buffer [ curinput .locfield ] ; 
  627.         incr ( curinput .locfield ) ; 
  628.       } 
  629.       lab40: curcmd = eqtb [ curcs ] .hh.b0 ; 
  630.       curchr = eqtb [ curcs ] .hh .v.RH ; 
  631.       if ( curcmd >= 112 ) 
  632.       checkoutervalidity () ; 
  633.     } 
  634.     break ; 
  635.       case 14 : 
  636.       case 30 : 
  637.       case 46 : 
  638.     {
  639.       curcs = curchr + 1 ; 
  640.       curcmd = eqtb [ curcs ] .hh.b0 ; 
  641.       curchr = eqtb [ curcs ] .hh .v.RH ; 
  642.       curinput .statefield = 1 ; 
  643.       if ( curcmd >= 112 ) 
  644.       checkoutervalidity () ; 
  645.     } 
  646.     break ; 
  647.       case 8 : 
  648.       case 24 : 
  649.       case 40 : 
  650.     {
  651.       if ( ( curchr == buffer [ curinput .locfield ] ) && ( curinput 
  652.       .locfield < curinput .limitfield ) ) 
  653.       {
  654.         if ( buffer [ curinput .locfield + 1 ] < 64 ) 
  655.         curchr = buffer [ curinput .locfield + 1 ] + 64 ; 
  656.         else curchr = buffer [ curinput .locfield + 1 ] - 64 ; 
  657.         curinput .locfield = curinput .locfield + 2 ; 
  658.         goto lab21 ; 
  659.       } 
  660.       curinput .statefield = 1 ; 
  661.     } 
  662.     break ; 
  663.       case 16 : 
  664.       case 32 : 
  665.       case 48 : 
  666.     {
  667.       {
  668.         if ( interaction == 3 ) 
  669.         wakeupterminal () ; 
  670.         printnl ( 133 ) ; 
  671.         print ( 471 ) ; 
  672.       } 
  673.       {
  674.         helpptr = 2 ; 
  675.         helpline [ 1 ] = 472 ; 
  676.         helpline [ 0 ] = 473 ; 
  677.       } 
  678.       deletionsallowed = false ; 
  679.       error () ; 
  680.       deletionsallowed = true ; 
  681.       goto lab20 ; 
  682.     } 
  683.     break ; 
  684.       case 11 : 
  685.     {
  686.       curinput .statefield = 17 ; 
  687.       curchr = 32 ; 
  688.     } 
  689.     break ; 
  690.       case 6 : 
  691.     {
  692.       curinput .locfield = curinput .limitfield + 1 ; 
  693.       curcmd = 10 ; 
  694.       curchr = 32 ; 
  695.     } 
  696.     break ; 
  697.       case 22 : 
  698.       case 15 : 
  699.       case 31 : 
  700.       case 47 : 
  701.     {
  702.       curinput .locfield = curinput .limitfield + 1 ; 
  703.       goto lab25 ; 
  704.     } 
  705.     break ; 
  706.       case 38 : 
  707.     {
  708.       curinput .locfield = curinput .limitfield + 1 ; 
  709.       curcs = parloc ; 
  710.       curcmd = eqtb [ curcs ] .hh.b0 ; 
  711.       curchr = eqtb [ curcs ] .hh .v.RH ; 
  712.       if ( curcmd >= 112 ) 
  713.       checkoutervalidity () ; 
  714.     } 
  715.     break ; 
  716.       case 2 : 
  717.     incr ( alignstate ) ; 
  718.     break ; 
  719.       case 18 : 
  720.       case 34 : 
  721.     {
  722.       curinput .statefield = 1 ; 
  723.       incr ( alignstate ) ; 
  724.     } 
  725.     break ; 
  726.       case 3 : 
  727.     decr ( alignstate ) ; 
  728.     break ; 
  729.       case 19 : 
  730.       case 35 : 
  731.     {
  732.       curinput .statefield = 1 ; 
  733.       decr ( alignstate ) ; 
  734.     } 
  735.     break ; 
  736.       case 20 : 
  737.       case 21 : 
  738.       case 23 : 
  739.       case 25 : 
  740.       case 28 : 
  741.       case 29 : 
  742.       case 36 : 
  743.       case 37 : 
  744.       case 39 : 
  745.       case 41 : 
  746.       case 44 : 
  747.       case 45 : 
  748.     curinput .statefield = 1 ; 
  749.     break ; 
  750.     default: 
  751.     ; 
  752.     break ; 
  753.       } 
  754.     } 
  755.     else {
  756.     
  757.       curinput .statefield = 33 ; 
  758.       if ( curinput .namefield > 17 ) 
  759.       {
  760.     incr ( line ) ; 
  761.     first = curinput .startfield ; 
  762.     if ( ! forceeof ) 
  763.     {
  764.       if ( inputln ( inputfile [ curinput .indexfield ] , true ) ) 
  765.       firmuptheline () ; 
  766.       else forceeof = true ; 
  767.     } 
  768.     if ( forceeof ) 
  769.     {
  770.       printchar ( 41 ) ; 
  771.       forceeof = false ; 
  772.       termflush ( stdout ) ; 
  773.       endfilereading () ; 
  774.       checkoutervalidity () ; 
  775.       goto lab20 ; 
  776.     } 
  777.     if ( ( eqtb [ 5315 ] .cint < 0 ) || ( eqtb [ 5315 ] .cint > 127 ) ) 
  778.     decr ( curinput .limitfield ) ; 
  779.     else buffer [ curinput .limitfield ] = eqtb [ 5315 ] .cint ; 
  780.     first = curinput .limitfield + 1 ; 
  781.     curinput .locfield = curinput .startfield ; 
  782.       } 
  783.       else {
  784.       
  785.     if ( ! ( curinput .namefield == 0 ) ) 
  786.     {
  787.       curcmd = 0 ; 
  788.       curchr = 0 ; 
  789.       return ; 
  790.     } 
  791.     if ( inputptr > 0 ) 
  792.     {
  793.       endfilereading () ; 
  794.       goto lab20 ; 
  795.     } 
  796.     if ( selector < 18 ) 
  797.     openlogfile () ; 
  798.     if ( interaction > 1 ) 
  799.     {
  800.       if ( ( eqtb [ 5315 ] .cint < 0 ) || ( eqtb [ 5315 ] .cint > 127 ) ) 
  801.       incr ( curinput .limitfield ) ; 
  802.       if ( curinput .limitfield == curinput .startfield ) 
  803.       printnl ( 474 ) ; 
  804.       println () ; 
  805.       first = curinput .startfield ; 
  806.       {
  807.         wakeupterminal () ; 
  808.         print ( 42 ) ; 
  809.         terminput () ; 
  810.       } 
  811.       curinput .limitfield = last ; 
  812.       if ( ( eqtb [ 5315 ] .cint < 0 ) || ( eqtb [ 5315 ] .cint > 127 ) ) 
  813.       decr ( curinput .limitfield ) ; 
  814.       else buffer [ curinput .limitfield ] = eqtb [ 5315 ] .cint ; 
  815.       first = curinput .limitfield + 1 ; 
  816.       curinput .locfield = curinput .startfield ; 
  817.     } 
  818.     else fatalerror ( 475 ) ; 
  819.       } 
  820.       {
  821.     if ( interrupt != 0 ) 
  822.     pauseforinstructions () ; 
  823.       } 
  824.       goto lab25 ; 
  825.     } 
  826.   } 
  827.   else if ( curinput .locfield != 0 ) 
  828.   {
  829.     t = mem [ curinput .locfield ] .hh .v.LH ; 
  830.     curinput .locfield = mem [ curinput .locfield ] .hh .v.RH ; 
  831.     if ( t >= 4096 ) 
  832.     {
  833.       curcs = t - 4096 ; 
  834.       curcmd = eqtb [ curcs ] .hh.b0 ; 
  835.       curchr = eqtb [ curcs ] .hh .v.RH ; 
  836.       if ( curcmd >= 112 ) 
  837.       if ( curcmd == 115 ) 
  838.       {
  839.     curcs = mem [ curinput .locfield ] .hh .v.LH - 4096 ; 
  840.     curinput .locfield = 0 ; 
  841.     curcmd = eqtb [ curcs ] .hh.b0 ; 
  842.     curchr = eqtb [ curcs ] .hh .v.RH ; 
  843.     if ( curcmd > 99 ) 
  844.     {
  845.       curcmd = 0 ; 
  846.       curchr = 257 ; 
  847.     } 
  848.       } 
  849.       else checkoutervalidity () ; 
  850.     } 
  851.     else {
  852.     
  853.       curcmd = t / 256 ; 
  854.       curchr = t % 256 ; 
  855.       switch ( curcmd ) 
  856.       {case 1 : 
  857.     incr ( alignstate ) ; 
  858.     break ; 
  859.       case 2 : 
  860.     decr ( alignstate ) ; 
  861.     break ; 
  862.       case 5 : 
  863.     {
  864.       begintokenlist ( paramstack [ curinput .limitfield + curchr - 1 ] , 
  865.       0 ) ; 
  866.       goto lab20 ; 
  867.     } 
  868.     break ; 
  869.     default: 
  870.     ; 
  871.     break ; 
  872.       } 
  873.     } 
  874.   } 
  875.   else {
  876.       
  877.     endtokenlist () ; 
  878.     goto lab20 ; 
  879.   } 
  880.   if ( curcmd <= 5 ) 
  881.   if ( curcmd >= 4 ) 
  882.   if ( alignstate == 0 ) 
  883.   {
  884.     if ( scannerstatus == 4 ) 
  885.     fatalerror ( 762 ) ; 
  886.     curcmd = mem [ curalign + 5 ] .hh .v.LH ; 
  887.     mem [ curalign + 5 ] .hh .v.LH = curchr ; 
  888.     if ( curcmd == 63 ) 
  889.     begintokenlist ( memtop - 10 , 2 ) ; 
  890.     else begintokenlist ( mem [ curalign + 2 ] .cint , 2 ) ; 
  891.     alignstate = 1000000L ; 
  892.     goto lab20 ; 
  893.   } 
  894. } 
  895. firmuptheline () {
  896.     firmuptheline_regmem 
  897.   integer k  ; 
  898.   curinput .limitfield = last ; 
  899.   if ( eqtb [ 5295 ] .cint > 0 ) 
  900.   if ( interaction > 1 ) 
  901.   {
  902.     wakeupterminal () ; 
  903.     println () ; 
  904.     if ( curinput .startfield < curinput .limitfield ) 
  905.     {register integer for_end; k = curinput .startfield ; for_end = curinput 
  906.     .limitfield - 1 ; if ( k <= for_end) do 
  907.       print ( buffer [ k ] ) ; 
  908.     while ( k++ < for_end ) ; } 
  909.     first = curinput .limitfield ; 
  910.     {
  911.       wakeupterminal () ; 
  912.       print ( 476 ) ; 
  913.       terminput () ; 
  914.     } 
  915.     if ( last > first ) 
  916.     {
  917.       {register integer for_end; k = first ; for_end = last - 1 ; if ( k <= 
  918.       for_end) do 
  919.     buffer [ k + curinput .startfield - first ] = buffer [ k ] ; 
  920.       while ( k++ < for_end ) ; } 
  921.       curinput .limitfield = curinput .startfield + last - first ; 
  922.     } 
  923.   } 
  924. } 
  925. gettoken () {
  926.     gettoken_regmem 
  927.   nonewcontrolsequence = false ; 
  928.   getnext () ; 
  929.   nonewcontrolsequence = true ; 
  930.   if ( curcs == 0 ) 
  931.   curtok = ( curcmd * 256 ) + curchr ; 
  932.   else curtok = 4096 + curcs ; 
  933. } 
  934. macrocall () {
  935.     /* 10 22 30 31 40 */ macrocall_regmem 
  936.   halfword r  ; 
  937.   halfword p  ; 
  938.   halfword q  ; 
  939.   halfword s  ; 
  940.   halfword t  ; 
  941.   halfword u, v  ; 
  942.   halfword rbraceptr  ; 
  943.   smallnumber n  ; 
  944.   halfword unbalance  ; 
  945.   halfword m  ; 
  946.   halfword refcount  ; 
  947.   smallnumber savescannerstatus  ; 
  948.   halfword savewarningindex  ; 
  949.   ASCIIcode matchchr  ; 
  950.   savescannerstatus = scannerstatus ; 
  951.   savewarningindex = warningindex ; 
  952.   warningindex = curcs ; 
  953.   refcount = curchr ; 
  954.   r = mem [ refcount ] .hh .v.RH ; 
  955.   n = 0 ; 
  956.   if ( eqtb [ 5297 ] .cint > 0 ) 
  957.   {
  958.     begindiagnostic () ; 
  959.     println () ; 
  960.     printcs ( warningindex ) ; 
  961.     tokenshow ( refcount ) ; 
  962.     enddiagnostic ( false ) ; 
  963.   } 
  964.   if ( mem [ r ] .hh .v.LH != 3584 ) 
  965.   {
  966.     scannerstatus = 3 ; 
  967.     unbalance = 0 ; 
  968.     longstate = eqtb [ curcs ] .hh.b0 ; 
  969.     if ( longstate >= 112 ) 
  970.     longstate = longstate - 2 ; 
  971.     do {
  972.     if ( ( mem [ r ] .hh .v.LH > 3455 ) || ( mem [ r ] .hh .v.LH < 3328 ) 
  973.       ) 
  974.       s = 0 ; 
  975.       else {
  976.       
  977.     matchchr = mem [ r ] .hh .v.LH - 3328 ; 
  978.     s = mem [ r ] .hh .v.RH ; 
  979.     r = s ; 
  980.     p = memtop - 3 ; 
  981.     mem [ p ] .hh .v.RH = 0 ; 
  982.     m = 0 ; 
  983.       } 
  984.       lab22: gettoken () ; 
  985.       if ( curtok == mem [ r ] .hh .v.LH ) 
  986.       {
  987.     r = mem [ r ] .hh .v.RH ; 
  988.     if ( ( mem [ r ] .hh .v.LH >= 3328 ) && ( mem [ r ] .hh .v.LH <= 3584 
  989.     ) ) 
  990.     {
  991.       if ( curtok < 512 ) 
  992.       decr ( alignstate ) ; 
  993.       goto lab40 ; 
  994.     } 
  995.     else goto lab22 ; 
  996.       } 
  997.       if ( s != r ) 
  998.       if ( s == 0 ) 
  999.       {
  1000.     {
  1001.       if ( interaction == 3 ) 
  1002.       wakeupterminal () ; 
  1003.       printnl ( 133 ) ; 
  1004.       print ( 508 ) ; 
  1005.     } 
  1006.     sprintcs ( warningindex ) ; 
  1007.     print ( 509 ) ; 
  1008.     {
  1009.       helpptr = 4 ; 
  1010.       helpline [ 3 ] = 510 ; 
  1011.       helpline [ 2 ] = 511 ; 
  1012.       helpline [ 1 ] = 512 ; 
  1013.       helpline [ 0 ] = 513 ; 
  1014.     } 
  1015.     error () ; 
  1016.     goto lab10 ; 
  1017.       } 
  1018.       else {
  1019.       
  1020.     t = s ; 
  1021.     do {
  1022.         { 
  1023.         q = getavail () ; 
  1024.         mem [ p ] .hh .v.RH = q ; 
  1025.         mem [ q ] .hh .v.LH = mem [ t ] .hh .v.LH ; 
  1026.         p = q ; 
  1027.       } 
  1028.       incr ( m ) ; 
  1029.       u = mem [ t ] .hh .v.RH ; 
  1030.       v = s ; 
  1031.       while ( true ) {
  1032.           
  1033.         if ( u == r ) 
  1034.         if ( curtok != mem [ v ] .hh .v.LH ) 
  1035.         goto lab30 ; 
  1036.         else {
  1037.         
  1038.           r = mem [ v ] .hh .v.RH ; 
  1039.           goto lab22 ; 
  1040.         } 
  1041.         if ( mem [ u ] .hh .v.LH != mem [ v ] .hh .v.LH ) 
  1042.         goto lab30 ; 
  1043.         u = mem [ u ] .hh .v.RH ; 
  1044.         v = mem [ v ] .hh .v.RH ; 
  1045.       } 
  1046.       lab30: t = mem [ t ] .hh .v.RH ; 
  1047.     } while ( ! ( t == r ) ) ; 
  1048.     r = s ; 
  1049.       } 
  1050.       if ( curtok == partoken ) 
  1051.       if ( longstate != 111 ) 
  1052.       {
  1053.     if ( longstate == 110 ) 
  1054.     {
  1055.       runaway () ; 
  1056.       {
  1057.         if ( interaction == 3 ) 
  1058.         wakeupterminal () ; 
  1059.         printnl ( 133 ) ; 
  1060.         print ( 503 ) ; 
  1061.       } 
  1062.       sprintcs ( warningindex ) ; 
  1063.       print ( 504 ) ; 
  1064.       {
  1065.         helpptr = 3 ; 
  1066.         helpline [ 2 ] = 505 ; 
  1067.         helpline [ 1 ] = 506 ; 
  1068.         helpline [ 0 ] = 507 ; 
  1069.       } 
  1070.       backerror () ; 
  1071.     } 
  1072.     pstack [ n ] = mem [ memtop - 3 ] .hh .v.RH ; 
  1073.     alignstate = alignstate - unbalance ; 
  1074.     {register integer for_end; m = 0 ; for_end = n ; if ( m <= for_end) 
  1075.     do 
  1076.       flushlist ( pstack [ m ] ) ; 
  1077.     while ( m++ < for_end ) ; } 
  1078.     goto lab10 ; 
  1079.       } 
  1080.       if ( curtok < 768 ) 
  1081.       if ( curtok < 512 ) 
  1082.       {
  1083.     unbalance = 1 ; 
  1084.     while ( true ) {
  1085.         
  1086.       {
  1087.         {
  1088.           q = avail ; 
  1089.           if ( q == 0 ) 
  1090.           q = getavail () ; 
  1091.           else {
  1092.           
  1093.         avail = mem [ q ] .hh .v.RH ; 
  1094.         mem [ q ] .hh .v.RH = 0 ; 
  1095.     ;
  1096. #ifdef STAT
  1097.         incr ( dynused ) ; 
  1098. #endif /* STAT */
  1099.           } 
  1100.         } 
  1101.         mem [ p ] .hh .v.RH = q ; 
  1102.         mem [ q ] .hh .v.LH = curtok ; 
  1103.         p = q ; 
  1104.       } 
  1105.       gettoken () ; 
  1106.       if ( curtok == partoken ) 
  1107.       if ( longstate != 111 ) 
  1108.       {
  1109.         if ( longstate == 110 ) 
  1110.         {
  1111.           runaway () ; 
  1112.           {
  1113.         if ( interaction == 3 ) 
  1114.         wakeupterminal () ; 
  1115.         printnl ( 133 ) ; 
  1116.         print ( 503 ) ; 
  1117.           } 
  1118.           sprintcs ( warningindex ) ; 
  1119.           print ( 504 ) ; 
  1120.           {
  1121.         helpptr = 3 ; 
  1122.         helpline [ 2 ] = 505 ; 
  1123.         helpline [ 1 ] = 506 ; 
  1124.         helpline [ 0 ] = 507 ; 
  1125.           } 
  1126.           backerror () ; 
  1127.         } 
  1128.         pstack [ n ] = mem [ memtop - 3 ] .hh .v.RH ; 
  1129.         alignstate = alignstate - unbalance ; 
  1130.         {register integer for_end; m = 0 ; for_end = n ; if ( m <= 
  1131.         for_end) do 
  1132.           flushlist ( pstack [ m ] ) ; 
  1133.         while ( m++ < for_end ) ; } 
  1134.         goto lab10 ; 
  1135.       } 
  1136.       if ( curtok < 768 ) 
  1137.       if ( curtok < 512 ) 
  1138.       incr ( unbalance ) ; 
  1139.       else {
  1140.           
  1141.         decr ( unbalance ) ; 
  1142.         if ( unbalance == 0 ) 
  1143.         goto lab31 ; 
  1144.       } 
  1145.     } 
  1146.     lab31: rbraceptr = p ; 
  1147.     {
  1148.       q = getavail () ; 
  1149.       mem [ p ] .hh .v.RH = q ; 
  1150.       mem [ q ] .hh .v.LH = curtok ; 
  1151.       p = q ; 
  1152.     } 
  1153.       } 
  1154.       else {
  1155.       
  1156.     backinput () ; 
  1157.     {
  1158.       if ( interaction == 3 ) 
  1159.       wakeupterminal () ; 
  1160.       printnl ( 133 ) ; 
  1161.       print ( 495 ) ; 
  1162.     } 
  1163.     sprintcs ( warningindex ) ; 
  1164.     print ( 496 ) ; 
  1165.     {
  1166.       helpptr = 6 ; 
  1167.       helpline [ 5 ] = 497 ; 
  1168.       helpline [ 4 ] = 498 ; 
  1169.       helpline [ 3 ] = 499 ; 
  1170.       helpline [ 2 ] = 500 ; 
  1171.       helpline [ 1 ] = 501 ; 
  1172.       helpline [ 0 ] = 502 ; 
  1173.     } 
  1174.     incr ( alignstate ) ; 
  1175.     longstate = 110 ; 
  1176.     curtok = partoken ; 
  1177.     inserror () ; 
  1178.       } 
  1179.       else {
  1180.       
  1181.     if ( curtok == 2592 ) 
  1182.     if ( mem [ r ] .hh .v.LH <= 3584 ) 
  1183.     if ( mem [ r ] .hh .v.LH >= 3328 ) 
  1184.     goto lab22 ; 
  1185.     {
  1186.       q = getavail () ; 
  1187.       mem [ p ] .hh .v.RH = q ; 
  1188.       mem [ q ] .hh .v.LH = curtok ; 
  1189.       p = q ; 
  1190.     } 
  1191.       } 
  1192.       incr ( m ) ; 
  1193.       if ( mem [ r ] .hh .v.LH > 3584 ) 
  1194.       goto lab22 ; 
  1195.       if ( mem [ r ] .hh .v.LH < 3328 ) 
  1196.       goto lab22 ; 
  1197.       lab40: if ( s != 0 ) 
  1198.       {
  1199.     if ( ( m == 1 ) && ( mem [ p ] .hh .v.LH < 768 ) && ( p != memtop - 3 
  1200.     ) ) 
  1201.     {
  1202.       mem [ rbraceptr ] .hh .v.RH = 0 ; 
  1203.       {
  1204.         mem [ p ] .hh .v.RH = avail ; 
  1205.         avail = p ; 
  1206.     ;
  1207. #ifdef STAT
  1208.         decr ( dynused ) ; 
  1209. #endif /* STAT */
  1210.       } 
  1211.       p = mem [ memtop - 3 ] .hh .v.RH ; 
  1212.       pstack [ n ] = mem [ p ] .hh .v.RH ; 
  1213.       {
  1214.         mem [ p ] .hh .v.RH = avail ; 
  1215.         avail = p ; 
  1216.     ;
  1217. #ifdef STAT
  1218.         decr ( dynused ) ; 
  1219. #endif /* STAT */
  1220.       } 
  1221.     } 
  1222.     else pstack [ n ] = mem [ memtop - 3 ] .hh .v.RH ; 
  1223.     incr ( n ) ; 
  1224.     if ( eqtb [ 5297 ] .cint > 0 ) 
  1225.     {
  1226.       begindiagnostic () ; 
  1227.       printnl ( matchchr ) ; 
  1228.       printint ( n ) ; 
  1229.       print ( 514 ) ; 
  1230.       showtokenlist ( pstack [ n - 1 ] , 0 , 1000 ) ; 
  1231.       enddiagnostic ( false ) ; 
  1232.     } 
  1233.       } 
  1234.     } while ( ! ( mem [ r ] .hh .v.LH == 3584 ) ) ; 
  1235.   } 
  1236.   while ( ( curinput .statefield == 0 ) && ( curinput .locfield == 0 ) ) 
  1237.   endtokenlist () ; 
  1238.   begintokenlist ( refcount , 5 ) ; 
  1239.   curinput .namefield = warningindex ; 
  1240.   curinput .locfield = mem [ r ] .hh .v.RH ; 
  1241.   if ( n > 0 ) 
  1242.   {
  1243.     if ( paramptr + n > maxparamstack ) 
  1244.     {
  1245.       maxparamstack = paramptr + n ; 
  1246.       if ( maxparamstack > paramsize ) 
  1247.       overflow ( 494 , paramsize ) ; 
  1248.     } 
  1249.     {register integer for_end; m = 0 ; for_end = n - 1 ; if ( m <= for_end) 
  1250.     do 
  1251.       paramstack [ paramptr + m ] = pstack [ m ] ; 
  1252.     while ( m++ < for_end ) ; } 
  1253.     paramptr = paramptr + n ; 
  1254.   } 
  1255.   lab10: scannerstatus = savescannerstatus ; 
  1256.   warningindex = savewarningindex ; 
  1257. } 
  1258. insertrelax () {
  1259.     insertrelax_regmem 
  1260.   curtok = 4096 + curcs ; 
  1261.   backinput () ; 
  1262.   curtok = 7361 ; 
  1263.   backinput () ; 
  1264.   curinput .indexfield = 4 ; 
  1265. } 
  1266. expand () {
  1267.     expand_regmem 
  1268.   halfword t  ; 
  1269.   halfword p, q, r  ; 
  1270.   integer j  ; 
  1271.   integer cvbackup  ; 
  1272.   smallnumber cvlbackup, radixbackup, cobackup  ; 
  1273.   halfword backupbackup  ; 
  1274.   smallnumber savescannerstatus  ; 
  1275.   cvbackup = curval ; 
  1276.   cvlbackup = curvallevel ; 
  1277.   radixbackup = radix ; 
  1278.   cobackup = curorder ; 
  1279.   backupbackup = mem [ memtop - 13 ] .hh .v.RH ; 
  1280.   if ( curcmd < 110 ) 
  1281.   {
  1282.     if ( eqtb [ 5303 ] .cint > 1 ) 
  1283.     showcurcmdchr () ; 
  1284.     switch ( curcmd ) 
  1285.     {case 109 : 
  1286.       {
  1287.     if ( curmark [ curchr ] != 0 ) 
  1288.     begintokenlist ( curmark [ curchr ] , 14 ) ; 
  1289.       } 
  1290.       break ; 
  1291.     case 101 : 
  1292.       {
  1293.     gettoken () ; 
  1294.     t = curtok ; 
  1295.     gettoken () ; 
  1296.     if ( curcmd > 99 ) 
  1297.     expand () ; 
  1298.     else backinput () ; 
  1299.     curtok = t ; 
  1300.     backinput () ; 
  1301.       } 
  1302.       break ; 
  1303.     case 102 : 
  1304.       {
  1305.     savescannerstatus = scannerstatus ; 
  1306.     scannerstatus = 0 ; 
  1307.     gettoken () ; 
  1308.     scannerstatus = savescannerstatus ; 
  1309.     t = curtok ; 
  1310.     backinput () ; 
  1311.     if ( t >= 4096 ) 
  1312.     {
  1313.       p = getavail () ; 
  1314.       mem [ p ] .hh .v.LH = 7363 ; 
  1315.       mem [ p ] .hh .v.RH = curinput .locfield ; 
  1316.       curinput .startfield = p ; 
  1317.       curinput .locfield = p ; 
  1318.     } 
  1319.       } 
  1320.       break ; 
  1321.     case 106 : 
  1322.       {
  1323.     r = getavail () ; 
  1324.     p = r ; 
  1325.     do {
  1326.         getxtoken () ; 
  1327.       if ( curcs == 0 ) 
  1328.       {
  1329.         q = getavail () ; 
  1330.         mem [ p ] .hh .v.RH = q ; 
  1331.         mem [ q ] .hh .v.LH = curtok ; 
  1332.         p = q ; 
  1333.       } 
  1334.     } while ( ! ( curcs != 0 ) ) ; 
  1335.     if ( curcmd != 66 ) 
  1336.     {
  1337.       {
  1338.         if ( interaction == 3 ) 
  1339.         wakeupterminal () ; 
  1340.         printnl ( 133 ) ; 
  1341.         print ( 483 ) ; 
  1342.       } 
  1343.       printesc ( 364 ) ; 
  1344.       print ( 484 ) ; 
  1345.       {
  1346.         helpptr = 2 ; 
  1347.         helpline [ 1 ] = 485 ; 
  1348.         helpline [ 0 ] = 486 ; 
  1349.       } 
  1350.       backerror () ; 
  1351.     } 
  1352.     j = first ; 
  1353.     p = mem [ r ] .hh .v.RH ; 
  1354.     while ( p != 0 ) {
  1355.         
  1356.       if ( j >= maxbufstack ) 
  1357.       {
  1358.         maxbufstack = j + 1 ; 
  1359.         if ( maxbufstack == bufsize ) 
  1360.         overflow ( 454 , bufsize ) ; 
  1361.       } 
  1362.       buffer [ j ] = mem [ p ] .hh .v.LH % 256 ; 
  1363.       incr ( j ) ; 
  1364.       p = mem [ p ] .hh .v.RH ; 
  1365.     } 
  1366.     if ( j > first + 1 ) 
  1367.     {
  1368.       nonewcontrolsequence = false ; 
  1369.       curcs = idlookup ( first , j - first ) ; 
  1370.       nonewcontrolsequence = true ; 
  1371.     } 
  1372.     else if ( j == first ) 
  1373.     curcs = 257 ; 
  1374.     else curcs = 129 + buffer [ first ] ; 
  1375.     flushlist ( r ) ; 
  1376.     if ( eqtb [ curcs ] .hh.b0 == 100 ) 
  1377.     {
  1378.       eqdefine ( curcs , 0 , 256 ) ; 
  1379.     } 
  1380.     curtok = curcs + 4096 ; 
  1381.     backinput () ; 
  1382.       } 
  1383.       break ; 
  1384.     case 107 : 
  1385.       convtoks () ; 
  1386.       break ; 
  1387.     case 108 : 
  1388.       insthetoks () ; 
  1389.       break ; 
  1390.     case 104 : 
  1391.       conditional () ; 
  1392.       break ; 
  1393.     case 105 : 
  1394.       if ( curchr > iflimit ) 
  1395.       if ( iflimit == 1 ) 
  1396.       insertrelax () ; 
  1397.       else {
  1398.       
  1399.     {
  1400.       if ( interaction == 3 ) 
  1401.       wakeupterminal () ; 
  1402.       printnl ( 133 ) ; 
  1403.       print ( 633 ) ; 
  1404.     } 
  1405.     printcmdchr ( 105 , curchr ) ; 
  1406.     {
  1407.       helpptr = 1 ; 
  1408.       helpline [ 0 ] = 634 ; 
  1409.     } 
  1410.     error () ; 
  1411.       } 
  1412.       else {
  1413.       
  1414.     while ( curchr != 2 ) passtext () ; 
  1415.     {
  1416.       p = condptr ; 
  1417.       ifline = mem [ p + 1 ] .cint ; 
  1418.       curif = mem [ p ] .hh.b1 ; 
  1419.       iflimit = mem [ p ] .hh.b0 ; 
  1420.       condptr = mem [ p ] .hh .v.RH ; 
  1421.       freenode ( p , 2 ) ; 
  1422.     } 
  1423.       } 
  1424.       break ; 
  1425.     case 103 : 
  1426.       if ( curchr > 0 ) 
  1427.       forceeof = true ; 
  1428.       else if ( nameinprogress ) 
  1429.       insertrelax () ; 
  1430.       else startinput () ; 
  1431.       break ; 
  1432.       default: 
  1433.       {
  1434.     {
  1435.       if ( interaction == 3 ) 
  1436.       wakeupterminal () ; 
  1437.       printnl ( 133 ) ; 
  1438.       print ( 477 ) ; 
  1439.     } 
  1440.     {
  1441.       helpptr = 5 ; 
  1442.       helpline [ 4 ] = 478 ; 
  1443.       helpline [ 3 ] = 479 ; 
  1444.       helpline [ 2 ] = 480 ; 
  1445.       helpline [ 1 ] = 481 ; 
  1446.       helpline [ 0 ] = 482 ; 
  1447.     } 
  1448.     error () ; 
  1449.       } 
  1450.       break ; 
  1451.     } 
  1452.   } 
  1453.   else if ( curcmd < 114 ) 
  1454.   macrocall () ; 
  1455.   else {
  1456.       
  1457.     curtok = 7360 ; 
  1458.     backinput () ; 
  1459.   } 
  1460.   curval = cvbackup ; 
  1461.   curvallevel = cvlbackup ; 
  1462.   radix = radixbackup ; 
  1463.   curorder = cobackup ; 
  1464.   mem [ memtop - 13 ] .hh .v.RH = backupbackup ; 
  1465. } 
  1466. getxtoken () {
  1467.     /* 20 30 */ getxtoken_regmem 
  1468.   lab20: getnext () ; 
  1469.   if ( curcmd <= 99 ) 
  1470.   goto lab30 ; 
  1471.   if ( curcmd >= 110 ) 
  1472.   if ( curcmd < 114 ) 
  1473.   macrocall () ; 
  1474.   else {
  1475.       
  1476.     curcs = 3264 ; 
  1477.     curcmd = 9 ; 
  1478.     goto lab30 ; 
  1479.   } 
  1480.   else expand () ; 
  1481.   goto lab20 ; 
  1482.   lab30: if ( curcs == 0 ) 
  1483.   curtok = ( curcmd * 256 ) + curchr ; 
  1484.   else curtok = 4096 + curcs ; 
  1485. } 
  1486. xtoken () {
  1487.     xtoken_regmem 
  1488.   while ( curcmd > 99 ) {
  1489.       
  1490.     expand () ; 
  1491.     getnext () ; 
  1492.   } 
  1493.   if ( curcs == 0 ) 
  1494.   curtok = ( curcmd * 256 ) + curchr ; 
  1495.   else curtok = 4096 + curcs ; 
  1496. } 
  1497. scanleftbrace () {
  1498.     scanleftbrace_regmem 
  1499.   do {
  1500.       getxtoken () ; 
  1501.   } while ( ! ( ( curcmd != 10 ) && ( curcmd != 0 ) ) ) ; 
  1502.   if ( curcmd != 1 ) 
  1503.   {
  1504.     {
  1505.       if ( interaction == 3 ) 
  1506.       wakeupterminal () ; 
  1507.       printnl ( 133 ) ; 
  1508.       print ( 515 ) ; 
  1509.     } 
  1510.     {
  1511.       helpptr = 4 ; 
  1512.       helpline [ 3 ] = 516 ; 
  1513.       helpline [ 2 ] = 517 ; 
  1514.       helpline [ 1 ] = 518 ; 
  1515.       helpline [ 0 ] = 519 ; 
  1516.     } 
  1517.     backerror () ; 
  1518.     curtok = 379 ; 
  1519.     curcmd = 1 ; 
  1520.     curchr = 123 ; 
  1521.     incr ( alignstate ) ; 
  1522.   } 
  1523. } 
  1524. scanoptionalequals () {
  1525.     scanoptionalequals_regmem 
  1526.   do {
  1527.       getxtoken () ; 
  1528.   } while ( ! ( curcmd != 10 ) ) ; 
  1529.   if ( curtok != 3133 ) 
  1530.   backinput () ; 
  1531. } 
  1532. boolean zscankeyword ( s ) 
  1533. strnumber s ; 
  1534. {/* 10 */ register boolean Result; scankeyword_regmem 
  1535.   halfword p  ; 
  1536.   halfword q  ; 
  1537.   poolpointer k  ; 
  1538.   p = memtop - 13 ; 
  1539.   mem [ p ] .hh .v.RH = 0 ; 
  1540.   k = strstart [ s ] ; 
  1541.   while ( k < strstart [ s + 1 ] ) {
  1542.       
  1543.     getxtoken () ; 
  1544.     if ( ( curcs == 0 ) && ( ( curchr == strpool [ k ] ) || ( curchr == 
  1545.     strpool [ k ] - 32 ) ) ) 
  1546.     {
  1547.       {
  1548.     q = getavail () ; 
  1549.     mem [ p ] .hh .v.RH = q ; 
  1550.     mem [ q ] .hh .v.LH = curtok ; 
  1551.     p = q ; 
  1552.       } 
  1553.       incr ( k ) ; 
  1554.     } 
  1555.     else if ( ( curcmd != 10 ) || ( p != memtop - 13 ) ) 
  1556.     {
  1557.       backinput () ; 
  1558.       if ( p != memtop - 13 ) 
  1559.       begintokenlist ( mem [ memtop - 13 ] .hh .v.RH , 3 ) ; 
  1560.       Result = false ; 
  1561.       return(Result) ; 
  1562.     } 
  1563.   } 
  1564.   flushlist ( mem [ memtop - 13 ] .hh .v.RH ) ; 
  1565.   Result = true ; 
  1566.   return(Result) ; 
  1567. } 
  1568. muerror () {
  1569.     muerror_regmem 
  1570.   {
  1571.     if ( interaction == 3 ) 
  1572.     wakeupterminal () ; 
  1573.     printnl ( 133 ) ; 
  1574.     print ( 520 ) ; 
  1575.   } 
  1576.   {
  1577.     helpptr = 1 ; 
  1578.     helpline [ 0 ] = 521 ; 
  1579.   } 
  1580.   error () ; 
  1581. } 
  1582. scansevenbitint () {
  1583.     scansevenbitint_regmem 
  1584.   scanint () ; 
  1585.   if ( ( curval < 0 ) || ( curval > 127 ) ) 
  1586.   {
  1587.     {
  1588.       if ( interaction == 3 ) 
  1589.       wakeupterminal () ; 
  1590.       printnl ( 133 ) ; 
  1591.       print ( 543 ) ; 
  1592.     } 
  1593.     {
  1594.       helpptr = 2 ; 
  1595.       helpline [ 1 ] = 544 ; 
  1596.       helpline [ 0 ] = 545 ; 
  1597.     } 
  1598.     interror ( curval ) ; 
  1599.     curval = 0 ; 
  1600.   } 
  1601. } 
  1602. scaneightbitint () {
  1603.     scaneightbitint_regmem 
  1604.   scanint () ; 
  1605.   if ( ( curval < 0 ) || ( curval > 255 ) ) 
  1606.   {
  1607.     {
  1608.       if ( interaction == 3 ) 
  1609.       wakeupterminal () ; 
  1610.       printnl ( 133 ) ; 
  1611.       print ( 546 ) ; 
  1612.     } 
  1613.     {
  1614.       helpptr = 2 ; 
  1615.       helpline [ 1 ] = 547 ; 
  1616.       helpline [ 0 ] = 545 ; 
  1617.     } 
  1618.     interror ( curval ) ; 
  1619.     curval = 0 ; 
  1620.   } 
  1621. } 
  1622. scanfourbitint () {
  1623.     scanfourbitint_regmem 
  1624.   scanint () ; 
  1625.   if ( ( curval < 0 ) || ( curval > 15 ) ) 
  1626.   {
  1627.     {
  1628.       if ( interaction == 3 ) 
  1629.       wakeupterminal () ; 
  1630.       printnl ( 133 ) ; 
  1631.       print ( 548 ) ; 
  1632.     } 
  1633.     {
  1634.       helpptr = 2 ; 
  1635.       helpline [ 1 ] = 549 ; 
  1636.       helpline [ 0 ] = 545 ; 
  1637.     } 
  1638.     interror ( curval ) ; 
  1639.     curval = 0 ; 
  1640.   } 
  1641. } 
  1642. scancharnum () {
  1643.     scancharnum_regmem 
  1644.   scanint () ; 
  1645.   if ( ( curval < 0 ) || ( curval > 255 ) ) 
  1646.   {
  1647.     {
  1648.       if ( interaction == 3 ) 
  1649.       wakeupterminal () ; 
  1650.       printnl ( 133 ) ; 
  1651.       print ( 543 ) ; 
  1652.     } 
  1653.     {
  1654.       helpptr = 2 ; 
  1655.       helpline [ 1 ] = 550 ; 
  1656.       helpline [ 0 ] = 545 ; 
  1657.     } 
  1658.     interror ( curval ) ; 
  1659.     curval = 0 ; 
  1660.   } 
  1661. } 
  1662. scanfifteenbitint () {
  1663.     scanfifteenbitint_regmem 
  1664.   scanint () ; 
  1665.   if ( ( curval < 0 ) || ( curval > 32767 ) ) 
  1666.   {
  1667.     {
  1668.       if ( interaction == 3 ) 
  1669.       wakeupterminal () ; 
  1670.       printnl ( 133 ) ; 
  1671.       print ( 551 ) ; 
  1672.     } 
  1673.     {
  1674.       helpptr = 2 ; 
  1675.       helpline [ 1 ] = 552 ; 
  1676.       helpline [ 0 ] = 545 ; 
  1677.     } 
  1678.     interror ( curval ) ; 
  1679.     curval = 0 ; 
  1680.   } 
  1681. } 
  1682. scantwentysevenbitin () {
  1683.     scantwentysevenbitin_regmem 
  1684.   scanint () ; 
  1685.   if ( ( curval < 0 ) || ( curval > 134217727L ) ) 
  1686.   {
  1687.     {
  1688.       if ( interaction == 3 ) 
  1689.       wakeupterminal () ; 
  1690.       printnl ( 133 ) ; 
  1691.       print ( 553 ) ; 
  1692.     } 
  1693.     {
  1694.       helpptr = 2 ; 
  1695.       helpline [ 1 ] = 554 ; 
  1696.       helpline [ 0 ] = 545 ; 
  1697.     } 
  1698.     interror ( curval ) ; 
  1699.     curval = 0 ; 
  1700.   } 
  1701. } 
  1702. scanfontident () {
  1703.     scanfontident_regmem 
  1704.   internalfontnumber f  ; 
  1705.   halfword m  ; 
  1706.   do {
  1707.       getxtoken () ; 
  1708.   } while ( ! ( curcmd != 10 ) ) ; 
  1709.   if ( curcmd == 87 ) 
  1710.   f = eqtb [ 4578 ] .hh .v.RH ; 
  1711.   else if ( curcmd == 86 ) 
  1712.   f = curchr ; 
  1713.   else if ( curcmd == 85 ) 
  1714.   {
  1715.     m = curchr ; 
  1716.     scanfourbitint () ; 
  1717.     f = eqtb [ m + curval ] .hh .v.RH ; 
  1718.   } 
  1719.   else {
  1720.       
  1721.     {
  1722.       if ( interaction == 3 ) 
  1723.       wakeupterminal () ; 
  1724.       printnl ( 133 ) ; 
  1725.       print ( 670 ) ; 
  1726.     } 
  1727.     {
  1728.       helpptr = 2 ; 
  1729.       helpline [ 1 ] = 671 ; 
  1730.       helpline [ 0 ] = 672 ; 
  1731.     } 
  1732.     backerror () ; 
  1733.     f = 0 ; 
  1734.   } 
  1735.   curval = f ; 
  1736. } 
  1737. zfindfontdimen ( writing ) 
  1738. boolean writing ; 
  1739. {findfontdimen_regmem 
  1740.   internalfontnumber f  ; 
  1741.   integer n  ; 
  1742.   scanint () ; 
  1743.   n = curval ; 
  1744.   scanfontident () ; 
  1745.   f = curval ; 
  1746.   if ( n <= 0 ) 
  1747.   curval = fmemptr ; 
  1748.   else {
  1749.       
  1750.     if ( writing && ( n <= 4 ) && ( n >= 2 ) && ( fontglue [ f ] != 0 ) ) 
  1751.     {
  1752.       deleteglueref ( fontglue [ f ] ) ; 
  1753.       fontglue [ f ] = 0 ; 
  1754.     } 
  1755.     if ( n > fontparams [ f ] ) 
  1756.     if ( f < fontptr ) 
  1757.     curval = fmemptr ; 
  1758.     else {
  1759.     
  1760.       do {
  1761.       if ( fmemptr == fontmemsize ) 
  1762.     overflow ( 677 , fontmemsize ) ; 
  1763.     fontinfo [ fmemptr ] .cint = 0 ; 
  1764.     incr ( fmemptr ) ; 
  1765.     incr ( fontparams [ f ] ) ; 
  1766.       } while ( ! ( n == fontparams [ f ] ) ) ; 
  1767.       curval = fmemptr - 1 ; 
  1768.     } 
  1769.     else curval = n + parambase [ f ] ; 
  1770.   } 
  1771.   if ( curval == fmemptr ) 
  1772.   {
  1773.     {
  1774.       if ( interaction == 3 ) 
  1775.       wakeupterminal () ; 
  1776.       printnl ( 133 ) ; 
  1777.       print ( 655 ) ; 
  1778.     } 
  1779.     printesc ( hash [ 3268 + f ] .v.RH ) ; 
  1780.     print ( 673 ) ; 
  1781.     printint ( fontparams [ f ] ) ; 
  1782.     print ( 674 ) ; 
  1783.     {
  1784.       helpptr = 2 ; 
  1785.       helpline [ 1 ] = 675 ; 
  1786.       helpline [ 0 ] = 676 ; 
  1787.     } 
  1788.     error () ; 
  1789.   } 
  1790. } 
  1791. zscansomethinginterna ( level , negative ) 
  1792. smallnumber level ; 
  1793. boolean negative ; 
  1794. {scansomethinginterna_regmem 
  1795.   halfword m  ; 
  1796.   integer p  ; 
  1797.   m = curchr ; 
  1798.   switch ( curcmd ) 
  1799.   {case 84 : 
  1800.     {
  1801.       scansevenbitint () ; 
  1802.       if ( m == 5139 ) 
  1803.       {
  1804.     curval = eqtb [ 5139 + curval ] .hh .v.RH ; 
  1805.     curvallevel = 0 ; 
  1806.       } 
  1807.       else if ( m < 5139 ) 
  1808.       {
  1809.     curval = eqtb [ m + curval ] .hh .v.RH ; 
  1810.     curvallevel = 0 ; 
  1811.       } 
  1812.       else {
  1813.       
  1814.     curval = eqtb [ m + curval ] .cint ; 
  1815.     curvallevel = 0 ; 
  1816.       } 
  1817.     } 
  1818.     break ; 
  1819.   case 70 : 
  1820.   case 71 : 
  1821.   case 85 : 
  1822.   case 86 : 
  1823.   case 87 : 
  1824.     if ( level != 5 ) 
  1825.     {
  1826.       {
  1827.     if ( interaction == 3 ) 
  1828.     wakeupterminal () ; 
  1829.     printnl ( 133 ) ; 
  1830.     print ( 522 ) ; 
  1831.       } 
  1832.       {
  1833.     helpptr = 3 ; 
  1834.     helpline [ 2 ] = 523 ; 
  1835.     helpline [ 1 ] = 524 ; 
  1836.     helpline [ 0 ] = 525 ; 
  1837.       } 
  1838.       backerror () ; 
  1839.       {
  1840.     curval = 0 ; 
  1841.     curvallevel = 1 ; 
  1842.       } 
  1843.     } 
  1844.     else if ( curcmd <= 71 ) 
  1845.     {
  1846.       if ( curcmd < 71 ) 
  1847.       {
  1848.     scaneightbitint () ; 
  1849.     m = 4066 + curval ; 
  1850.       } 
  1851.       {
  1852.     curval = eqtb [ m ] .hh .v.RH ; 
  1853.     curvallevel = 5 ; 
  1854.       } 
  1855.     } 
  1856.     else {
  1857.     
  1858.       backinput () ; 
  1859.       scanfontident () ; 
  1860.       {
  1861.     curval = 3268 + curval ; 
  1862.     curvallevel = 4 ; 
  1863.       } 
  1864.     } 
  1865.     break ; 
  1866.   case 72 : 
  1867.     {
  1868.       curval = eqtb [ m ] .cint ; 
  1869.       curvallevel = 0 ; 
  1870.     } 
  1871.     break ; 
  1872.   case 73 : 
  1873.     {
  1874.       curval = eqtb [ m ] .cint ; 
  1875.       curvallevel = 1 ; 
  1876.     } 
  1877.     break ; 
  1878.   case 74 : 
  1879.     {
  1880.       curval = eqtb [ m ] .hh .v.RH ; 
  1881.       curvallevel = 2 ; 
  1882.     } 
  1883.     break ; 
  1884.   case 75 : 
  1885.     {
  1886.       curval = eqtb [ m ] .hh .v.RH ; 
  1887.       curvallevel = 3 ; 
  1888.     } 
  1889.     break ; 
  1890.   case 78 : 
  1891.     if ( abs ( curlist .modefield ) != m ) 
  1892.     {
  1893.       {
  1894.     if ( interaction == 3 ) 
  1895.     wakeupterminal () ; 
  1896.     printnl ( 133 ) ; 
  1897.     print ( 536 ) ; 
  1898.       } 
  1899.       printcmdchr ( 78 , m ) ; 
  1900.       {
  1901.     helpptr = 4 ; 
  1902.     helpline [ 3 ] = 537 ; 
  1903.     helpline [ 2 ] = 538 ; 
  1904.     helpline [ 1 ] = 539 ; 
  1905.     helpline [ 0 ] = 540 ; 
  1906.       } 
  1907.       error () ; 
  1908.       if ( level != 5 ) 
  1909.       {
  1910.     curval = 0 ; 
  1911.     curvallevel = 1 ; 
  1912.       } 
  1913.       else {
  1914.       
  1915.     curval = 0 ; 
  1916.     curvallevel = 0 ; 
  1917.       } 
  1918.     } 
  1919.     else {
  1920.     
  1921.       curval = curlist .auxfield ; 
  1922.       if ( m == 1 ) 
  1923.       curvallevel = 1 ; 
  1924.       else curvallevel = 0 ; 
  1925.     } 
  1926.     break ; 
  1927.   case 79 : 
  1928.     {
  1929.       nest [ nestptr ] = curlist ; 
  1930.       p = nestptr ; 
  1931.       while ( abs ( nest [ p ] .modefield ) != 1 ) decr ( p ) ; 
  1932.       {
  1933.     curval = nest [ p ] .pgfield ; 
  1934.     curvallevel = 0 ; 
  1935.       } 
  1936.     } 
  1937.     break ; 
  1938.   case 81 : 
  1939.     {
  1940.       if ( m == 0 ) 
  1941.       curval = deadcycles ; 
  1942.       else curval = insertpenalties ; 
  1943.       curvallevel = 0 ; 
  1944.     } 
  1945.     break ; 
  1946.   case 80 : 
  1947.     {
  1948.       if ( pagecontents == 0 ) 
  1949.       if ( m == 0 ) 
  1950.       curval = 1073741823L ; 
  1951.       else curval = 0 ; 
  1952.       else curval = pagesofar [ m ] ; 
  1953.       curvallevel = 1 ; 
  1954.     } 
  1955.     break ; 
  1956.   case 83 : 
  1957.     {
  1958.       if ( eqtb [ 4056 ] .hh .v.RH == 0 ) 
  1959.       curval = 0 ; 
  1960.       else curval = mem [ eqtb [ 4056 ] .hh .v.RH ] .hh .v.LH ; 
  1961.       curvallevel = 0 ; 
  1962.     } 
  1963.     break ; 
  1964.   case 82 : 
  1965.     {
  1966.       scaneightbitint () ; 
  1967.       if ( eqtb [ 4322 + curval ] .hh .v.RH == 0 ) 
  1968.       curval = 0 ; 
  1969.       else curval = mem [ eqtb [ 4322 + curval ] .hh .v.RH + m ] .cint ; 
  1970.       curvallevel = 1 ; 
  1971.     } 
  1972.     break ; 
  1973.   case 67 : 
  1974.   case 68 : 
  1975.     {
  1976.       curval = curchr ; 
  1977.       curvallevel = 0 ; 
  1978.     } 
  1979.     break ; 
  1980.   case 76 : 
  1981.     {
  1982.       findfontdimen ( false ) ; 
  1983.       fontinfo [ fmemptr ] .cint = 0 ; 
  1984.       {
  1985.     curval = fontinfo [ curval ] .cint ; 
  1986.     curvallevel = 1 ; 
  1987.       } 
  1988.     } 
  1989.     break ; 
  1990.   case 77 : 
  1991.     {
  1992.       scanfontident () ; 
  1993.       if ( m == 0 ) 
  1994.       {
  1995.     curval = hyphenchar [ curval ] ; 
  1996.     curvallevel = 0 ; 
  1997.       } 
  1998.       else {
  1999.       
  2000.     curval = skewchar [ curval ] ; 
  2001.     curvallevel = 0 ; 
  2002.       } 
  2003.     } 
  2004.     break ; 
  2005.   case 88 : 
  2006.     {
  2007.       scaneightbitint () ; 
  2008.       switch ( m ) 
  2009.       {case 0 : 
  2010.     curval = eqtb [ 5317 + curval ] .cint ; 
  2011.     break ; 
  2012.       case 1 : 
  2013.     curval = eqtb [ 5721 + curval ] .cint ; 
  2014.     break ; 
  2015.       case 2 : 
  2016.     curval = eqtb [ 3544 + curval ] .hh .v.RH ; 
  2017.     break ; 
  2018.       case 3 : 
  2019.     curval = eqtb [ 3800 + curval ] .hh .v.RH ; 
  2020.     break ; 
  2021.       } 
  2022.       curvallevel = m ; 
  2023.     } 
  2024.     break ; 
  2025.   case 69 : 
  2026.     {
  2027.       if ( curchr == 2 ) 
  2028.       curval = 0 ; 
  2029.       else curval = 0 ; 
  2030.       curvallevel = curchr ; 
  2031.       if ( ! ( curlist .tailfield >= himemmin ) && ( curlist .modefield != 0 ) 
  2032.       ) 
  2033.       switch ( curchr ) 
  2034.       {case 0 : 
  2035.     if ( mem [ curlist .tailfield ] .hh.b0 == 12 ) 
  2036.     curval = mem [ curlist .tailfield + 1 ] .cint ; 
  2037.     break ; 
  2038.       case 1 : 
  2039.     if ( mem [ curlist .tailfield ] .hh.b0 == 11 ) 
  2040.     curval = mem [ curlist .tailfield + 1 ] .cint ; 
  2041.     break ; 
  2042.       case 2 : 
  2043.     if ( mem [ curlist .tailfield ] .hh.b0 == 10 ) 
  2044.     {
  2045.       curval = mem [ curlist .tailfield + 1 ] .hh .v.LH ; 
  2046.       if ( mem [ curlist .tailfield ] .hh.b1 == 99 ) 
  2047.       curvallevel = 3 ; 
  2048.     } 
  2049.     break ; 
  2050.       } 
  2051.       else if ( ( curlist .modefield == 1 ) && ( curlist .tailfield == curlist 
  2052.       .headfield ) ) 
  2053.       switch ( curchr ) 
  2054.       {case 0 : 
  2055.     curval = lastpenalty ; 
  2056.     break ; 
  2057.       case 1 : 
  2058.     curval = lastkern ; 
  2059.     break ; 
  2060.       case 2 : 
  2061.     if ( lastglue != 65535L ) 
  2062.     curval = lastglue ; 
  2063.     break ; 
  2064.       } 
  2065.     } 
  2066.     break ; 
  2067.     default: 
  2068.     {
  2069.       {
  2070.     if ( interaction == 3 ) 
  2071.     wakeupterminal () ; 
  2072.     printnl ( 133 ) ; 
  2073.     print ( 541 ) ; 
  2074.       } 
  2075.       printcmdchr ( curcmd , curchr ) ; 
  2076.       print ( 542 ) ; 
  2077.       printesc ( 395 ) ; 
  2078.       {
  2079.     helpptr = 1 ; 
  2080.     helpline [ 0 ] = 540 ; 
  2081.       } 
  2082.       error () ; 
  2083.       if ( level != 5 ) 
  2084.       {
  2085.     curval = 0 ; 
  2086.     curvallevel = 1 ; 
  2087.       } 
  2088.       else {
  2089.       
  2090.     curval = 0 ; 
  2091.     curvallevel = 0 ; 
  2092.       } 
  2093.     } 
  2094.     break ; 
  2095.   } 
  2096.   while ( curvallevel > level ) {
  2097.       
  2098.     if ( curvallevel == 2 ) 
  2099.     curval = mem [ curval + 1 ] .cint ; 
  2100.     else if ( curvallevel == 3 ) 
  2101.     muerror () ; 
  2102.     decr ( curvallevel ) ; 
  2103.   } 
  2104.   if ( negative ) 
  2105.   if ( curvallevel >= 2 ) 
  2106.   {
  2107.     curval = newspec ( curval ) ; 
  2108.     {
  2109.       mem [ curval + 1 ] .cint = - (integer) mem [ curval + 1 ] .cint ; 
  2110.       mem [ curval + 2 ] .cint = - (integer) mem [ curval + 2 ] .cint ; 
  2111.       mem [ curval + 3 ] .cint = - (integer) mem [ curval + 3 ] .cint ; 
  2112.     } 
  2113.   } 
  2114.   else curval = - (integer) curval ; 
  2115.   else if ( ( curvallevel >= 2 ) && ( curvallevel <= 3 ) ) 
  2116.   incr ( mem [ curval ] .hh .v.RH ) ; 
  2117. } 
  2118.